home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / ingres04.lzh / source / libq / IIreadinp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-01-18  |  2.9 KB  |  172 lines
  1. # include    <useful.h>
  2. # include    <ingres.h>
  3. # include    <aux.h>
  4. # include    "IIglobals.h"
  5. # include    <sccs.h>
  6. # include    <errors.h>
  7.  
  8. SCCSID(@(#)IIreadinp.c    8.3    1/18/88)
  9.  
  10.  
  11. static char    IInbuf[70];
  12. static char    *IInb_free;
  13.  
  14. char    *
  15. IIneed(i)
  16. register     i;
  17. {
  18.     register char    *p;
  19.  
  20.     p = IInb_free;
  21.     if (IInb_free + i - IInbuf >= sizeof IInbuf)
  22.         IIsyserr("Error param overflow");
  23.     IInb_free += i;
  24.     return (p);
  25. }
  26.  
  27. IInd_init()
  28. {
  29.     IInb_free = IInbuf;
  30. }
  31.  
  32. /*
  33. **  IIREADINPUT -- read the input pipe 
  34. **
  35. **    The input pipe is read (using pb_get).  Parameters are
  36. **    collected and set up in the global IIerr_pv.  
  37. **
  38. **    If an error block is read, the error routine processing
  39. **    is invoked.
  40. **
  41. **    Parameters:
  42. **        ppb -- a pointer to the pipe block to read into;
  43. **            also becomes part of the return value.
  44. **
  45. **    Returns:
  46. **
  47. **    Requires:
  48. **        pb_prime, pb_get -- to read from the pipe.
  49. **        IIneed -- to get space to store things
  50. **            from the pipe.
  51. **
  52. **    History:
  53. **        8/21/79 (eric) -- written.
  54. */
  55.  
  56. IIreadinput(ppb)
  57. register pb_t    *ppb;
  58. {
  59.     register int    i;
  60.     int        pc;
  61.     char        *pv[20];
  62.     auto int    eno;
  63.  
  64.     /* if this is a response block, return immediately */
  65.     if (ppb->pb_type == PB_RESP)
  66.     {
  67.         i = IIpb_get(ppb, &IIresp, sizeof IIresp);
  68.         if (i != sizeof IIresp)
  69.             IIsyserr("readinput: IIresp sz %d", i);
  70.         IItupcnt = IIresp.resp_tups;
  71.     }
  72.  
  73.     /*
  74.     **  Parameter Loop.
  75.     **    Wander through and start reading parameters.
  76.     */
  77.  
  78.     IInd_init();
  79.     for (pc = 0 ; pc < PV_MAXPC; pc++)
  80.     {
  81.         if (IIread_arg(ppb, &pv[pc]) == PV_EOF)
  82.             break;
  83.     }
  84.  
  85.     /* out of loop, check for vector overflow */
  86.     if (pc >= sizeof pv / sizeof pv[0])
  87.         IIsyserr("readinput: overflow");
  88.  
  89.     /* check for error blocks */
  90.     if (ppb->pb_type == PB_ERR)
  91.     {
  92.         IIatoi(pv[0], &eno);
  93.         IIerror(eno, pc - 1, &pv[1]);
  94.     }
  95. }
  96. /*
  97. **  IIREAD_ARG -- Read a single argument from pipe
  98. **
  99. **    An argument can be as simple as an integer, or as complex
  100. **    as a query tree.
  101. **
  102. **    Parameters:
  103. **        ppb -- the pipe block to read from.
  104. **        pparm -- the parameter descripter to put the
  105. **            argument in.
  106. **
  107. **    Returns:
  108. **        PV_EOF -- if last arg read
  109. **
  110. **    Side Effects:
  111. **        May allocate space from Qbuf for trees, etc.
  112. **
  113. **    Requires:
  114. **        pb_get
  115. **        syserr
  116. **        need
  117. **        readqtree
  118. **
  119. **    Called By:
  120. **        readinput
  121. **
  122. **    Trace Flags:
  123. **        10.6 - 10.7
  124. */
  125.  
  126. IIread_arg(ppb, parm)
  127. register pb_t    *ppb;
  128. char        **parm;
  129. {
  130.     char        buf[20];
  131.     auto char    ptype;
  132.     auto short    plen;
  133.     register int    i;
  134.     register char    *p;
  135.     char        *ib;
  136.     short        j;
  137.     char        *IIneed();
  138.     char        *IIitos();
  139.  
  140.     /* get the parameter type */
  141.     i = IIpb_get(ppb, &ptype, 1);
  142.     if (i == 0)
  143.     {
  144.         return (PV_EOF);
  145.     }
  146.     i = IIpb_get(ppb, &plen, 2);
  147.     if (i < 2)
  148.         IIsyserr("readarg: pb_get %d", i);
  149.  
  150.     /* figure out the type */
  151.     switch (ptype)
  152.     {
  153.       case PV_INT:
  154.         IIpb_get(ppb, &j, plen);
  155.         ib = IIitos(j);
  156.         p = IIneed(j = IIlength(ib) + 1);
  157.         IIbmove(ib, p, j);
  158.         break;
  159.  
  160.       case PV_STR:
  161.         p = IIneed(plen + 1);
  162.         IIpb_get(ppb, p, plen);
  163.         p[plen] = 0;
  164.         break;
  165.  
  166.       default:
  167.         IIsyserr("readinput: type %d len %d", ptype, plen);
  168.     }
  169.     *parm = p;
  170.     return (ptype);
  171. }
  172.